// reflect es2015全新内置 
//统一对象操作  属于静态类  内部封装了一系列对对象的底层操作

// Reflect   14个废弃1个 

// Reflect成员方法就是proxy处理对象的默认实现

// const obj = {
//     foo:'123',
//     bar:'456'
// }

// const proxy = new Proxy(obj,{
//     get (target,property) {

//         console.log('312312')
//         return Reflect.get(target,property)
//     }
// })

// console.log(proxy.foo)


// const obj = {
//     name: 'zcr',
//     age: 18
// }

// es将来会废弃这些方法
// console.log('name' in obj)
// console.log(delete obj['age'])
// console.log(Object.keys(obj))

// console.log(Reflect.has(obj,'name'))
// console.log(Reflect.deleteProperty(obj,'name'))
// console.log(Reflect.ownKeys(obj))




// ---------------------------------------------
// Promise  解决传统异步编程中回调函数嵌套过深的问题


//---------------------------------------------------
// class


// function Porson(name) {
//     this.name = name
// }

// Proxy.prototype.say = function () {
//     console.log(`hi ${this.name}`)
// }


// class Porson{
//     constructor (name) {  // 当前方法的 构造函数 
//         this.name = name
//     }
//     say () {
//         console.log(`hi,my name is ${this.name}`)
//     }
// }

// const p = new Porson('tom')

// p.say()


//-------------------------------------
// 实例方法 vs 静态方法
// 实例方法  需要通过类型构造的实例对象调用
// 静态方法  直接通过类型本身调用

// static  新增添加静态成员 关键字


// class Porson{
//     constructor (name) {  // 当前方法的 构造函数 
//         this.name = name
//     }
//     say () {
//         console.log(`hi,my name is ${this.name}`)
//     }

//     static create (name) {
//         return new Porson(name)
//     }
//     // * 静态方法挂载到类型上，所以this会指向当前的类型
// }
// const tom = Porson.create('tom')
// tom.say()


//----------------------------------------
// 继承  extends

// class Porson{
//     constructor (name) {  // 当前方法的 构造函数 
//         this.name = name
//     }
//     say () {
//         console.log(`hi,my name is ${this.name}`)
//     }
// }

// class Student extends Porson {
//     constructor (name, number) {
//         super(name)  // 调用父类的 构造函数
//         this.number = number
//     }

//     hello() {
//         super.say() // 调用父类的 构造函数
//         console.log(`my school number ${this.number}`)
//     }
// }

// const s = new Student('jack','100')
// s.hello()



//--------------------------------------------
// Set 数据结构   内部成员不允许重复
// const s = new Set()

// s.add(1).add(2).add(3).add(1).add(2).add(3)

// console.log(s)
// s.forEach(i => console.log(i));

// for (let i of s){
//     console.log(i)
// }

// console.log(s.size)  //获取数组长度

// console.log(s.has(100))  //判断数组是非包含 

// console.log(s.delete(3))  //删除指定下标的值

// s.clear() // 清空数组
// console.log(s)


// Set常被用来数组去重
// const arr = [1,2,3,1,13,4,2412,42,1,2,24,34]
// const result = new Set(arr)
// const result = Array.from(new Set(arr))
// const result = [...new Set(arr)]

// console.log(result)



//--------------------------------------------
// Map数组结构  使用任意类型作为键

// const obj = {}
// obj[true] = 'value'
// obj[123] = 'value'
// obj[{a:1}] = 'value'

// console.log(Object.keys(obj))

// const m = new Map()
// const tom = {name:'tom'}
// m.set(tom,90)
// console.log(m)
// console.log(m.get(tom)) //获取

// m.has // 判断是否包含该下标
// m.delete // 删除
// m.clear // 清楚

// // 遍历数组
// m.forEach((value,key) => {
//     console.log(value,key)
// })
